// utils
const dayjs = require('dayjs')

// modules
const response = require('../utils/methods/response.js')
const UserModule = require('../models/tableModels/userModule.js')
const MemberLevelModule = require('../models/tableModels/memberLevelModule.js')
const RegionModule = require('../models/tableModels/regionModule.js')
const LabelModule = require('../models/tableModels/labelModule.js')

// methods
const splitParams = require('../utils/methods/splitParams')
const jsonFormat = require('../utils/methods/jsonFormat')

// 用户表控制器
const userController = {
    /**
     * 用户列表
     * */
    userList: async ({ body }, res) => {
        try {
            // 参数拆分
            const { pageParams, otherParams } = splitParams(body)
            // 响应列表数据、数据总条数
            let responseList, total
            // 如果没有指定字段，则查询所有
            if (!otherParams) {
                // 获取表数据总条数
                total = (await UserModule.knexAllCount())[0]['count(*)']
                // 分页查询
                responseList = await UserModule.knexAllDescLimitSelect(pageParams, 'userId')
            } else {
                // 取出参数的个数和参数值
                const { paramsLength, paramsValue } = otherParams
                // 如果参数值有会员昵称，模糊匹配查询会员昵称
                if (Object.prototype.hasOwnProperty.call(paramsValue, 'username')) {
                    // 如果只有 username 字段，则直接模糊匹配
                    if (paramsLength === 1) {
                        responseList = await UserModule.knexLikeSelectLimitDesc('username', paramsValue.username, pageParams, 'userId')
                        total = (await UserModule.knexLikeSelect('username', paramsValue.username)).length
                    } else {
                        // 如果还有其他字段，则合并查询
                        const newSearchParams = jsonFormat(paramsValue)
                        delete newSearchParams.username
                        responseList = await UserModule.knexLikeAndOtherSelectLimitDesc('username', paramsValue.username, newSearchParams, pageParams, 'userId')
                        total = (await UserModule.knexLikeAndOtherSelect('username', paramsValue.username, newSearchParams)).length
                    }
                } else {
                    // 无会员昵称直接查询其他
                    responseList = await UserModule.knexSelectFiledRowLimitDesc(paramsValue, pageParams, 'userId')
                    total = (await UserModule.knexSelectFiledRow(paramsValue)).length
                }
            }
            // 响应数据
            const responseData = {
                total,
                // 处理时间格式
                list: responseList.length ? jsonFormat(responseList).map(item => {
                    item.enterTime = dayjs(item.enterTime).format('YYYY-MM-DD HH:mm:ss')
                    item.birthday = dayjs(item.birthday).format('YYYY-MM-DD')
                    return item
                }) : []
            }
            response.success(res, responseData)
        } catch(err) {
            response.error(res, err)
        }
    },
    /**
     * 删除用户
     * */
    deleteUser: async (req, res) => {
        try {
            // 获取 userId 参数
            const userId = Number(req.query.userId)
            // 获取会员卡 id
            const { memberCardId, memberLevel: levelType, memberSource: regionName } = (await UserModule.knexSelectFiledColumn({ userId },  ['memberCardId', 'memberSource', 'memberLevel']))[0]
            // 删除标签表
            const labelDeleteRes = await LabelModule.delete('memberCardId', memberCardId)
            console.log('标签表删除结果', Boolean(labelDeleteRes))
            // 地区数量更新
            const { regionMemberNum } = (await RegionModule.knexSelectFiledColumn({ regionName }, ['regionMemberNum']))[0]
            const regionUpdateResult = await RegionModule.update({ regionName }, { regionMemberNum: regionMemberNum - 1 })
            console.log('地区表更新结果', Boolean(regionUpdateResult))
            // 会员等级表更新
            const { levelNum } = (await MemberLevelModule.knexSelectFiledColumn({ levelType }, ['levelNum']))[0]
            const levelUpdateResult = await MemberLevelModule.update({ levelType },{ levelNum: levelNum - 1 })
            console.log('等级表更新结果', levelUpdateResult)
            // 删除会员表会员
            const userRes = await UserModule.delete('userId', userId)
            console.log('用户表删除结果', userRes)
            // 用户表删除成功
            response.success(res, '删除成功')
        } catch(err) {
            response.error(res, err)
        }
    },
    /**
     * 会员详情
     * */
    userDetail: async (req, res) => {
        try {
            // 获取 userId 参数
            const userId = Number(req.query.userId)
            // 获取会员详情
            const memberDetailResult = (await UserModule.knexSelectFiledRow({ userId }))[0]
            // 获取标签表
            const labelResult = (await LabelModule.knexSelectFiledColumn({ memberCardId: memberDetailResult.memberCardId }, ['label']))[0]
            // 获取等级表等级名称
            const { levelName } = (await MemberLevelModule.selectLevelName(memberDetailResult.memberLevel))[0]
            // 响应数据
            const responseData = {
                ...memberDetailResult,
                levelName,
                tagList: labelResult.label ? labelResult.label.split(',') : []
            }
            // 返回会员详情
            response.success(res, responseData)
        } catch(err) {
            response.error(res, err)
        }
    },
    /**
     * 新增会员
     * */
    addUser: async ({ body }, res) => {
        try {
            // 插入会员表的数据
            const insertData = {
                ...body,
                // 成为会员时间
                enterTime: dayjs(new Date()).format('YYYY-MM-DD HH:mm:ss'),
                // 设置会员等级
                memberLevel: 1,
                // 设置会员状态
                memberStatus: 2,
                // 会员卡号, 初始化空
                memberCardId: ''
            }
            // 删除标签数据
            delete insertData.tagList
            // 判断是否为首次添加
            const isHasMember = (await UserModule.knexAllCount())[0]['count(*)']
            // 首次添加
            if (!isHasMember) {
                // 首次添加设置会员卡号
                insertData.memberCardId = 'X0000001'
            } else {
                // 非首次添加，获取最后一个会员的会员卡号
                const { memberCardId } = (await UserModule.selectLastData())[0]
                const [startSign, cardNum] = [memberCardId[0], Number(memberCardId.substring(1))]
                // 设置会员卡号
                insertData.memberCardId = `${startSign.padEnd(8 - String(cardNum).length, '0')}${cardNum + 1}`
            }
            // 更新地区表
            const { regionMemberNum } = (await RegionModule.knexSelectFiledColumn({ regionName: insertData.memberSource }, ['regionMemberNum']))[0]
            await RegionModule.update({ regionName: insertData.memberSource }, { regionMemberNum: regionMemberNum + 1 })
            // 更新初级会员等级表
            const { levelNum } = (await MemberLevelModule.knexSelectFiledColumn({ levelType: 1 }, ['levelNum']))[0]
            await MemberLevelModule.update({ levelType: 1 }, { levelNum: levelNum + 1 })
            // 插入会员表
            const userModuleResult = await UserModule.insert(insertData)
            // 会员表插入成功
            if (userModuleResult) {
                // 插入标签表
                const labelResult = await LabelModule.insert({
                    memberCardId: insertData.memberCardId,
                    label: body.tagList.length ? body.tagList.join(',') : ''
                })
                labelResult ? response.success(res, '更新成功！') : response.fail(res, '新增失败！')
            }
        } catch(err) {
            response.error(res, err)
        }
    },
    /**
     * 添加标签
     * */
    addLabel: async ({ query }, res) => {
        try {
            const { tagName, memberCardId } = query
            // 查询原有标签
            const { label } = (await LabelModule.knexSelectFiledColumn({ memberCardId }, ['label']))[0]
            const labelList = label ? label.split(',') : []
            labelList.push(tagName)
            // 插入新的标签
            const insertLabelResult = await LabelModule.update({ memberCardId }, { label: labelList.join(',') })
            insertLabelResult ? response.success(res, '更新成功！') : response.fail(res, '更新失败！')
        } catch(err) {
            response.error(res, err)
        }
    },
    /**
     * 会员分析
     * 会员总数、
     * */
    memberAnalysis: async (req, res) => {
        try {
            // 会员总数
            const memberTotal = (await UserModule.knexAllCount())[0]['count(*)']
            // 性别分布
            const womanNum = (await UserModule.knexFiledCount({ gender: 0 }))[0]['count(*)']
            const manNum = (await UserModule.knexFiledCount({ gender: 1 }))[0]['count(*)']
            // 地区分布
            const areaData = await RegionModule.knexAllDescLimitSelect({
                currentSize: 999,
                currentPage: 1
            }, 'regionMemberNum')
            /** ======================= 临时数据 */
            // 活跃度分布

            // 返回数据
            const responseData = {
                memberTotal,
                areaData,
                sexData: [
                    { name: '男', value: manNum },
                    { name: '女', value: womanNum }
                ]
            }
            response.success(res, responseData)
        } catch(err) {
            response.error(res, err)
        }
    }
}

module.exports = userController
